Termination w.r.t. Q of the following Term Rewriting System could be disproven:

Q restricted rewrite system:
The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.


QTRS
  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.

Using Dependency Pairs [1,15] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

ACTIVATE(n__sel(X1, X2)) → SEL(X1, X2)
UNQUOTE1(cons1(X, Z)) → FCONS(unquote(X), unquote1(Z))
QUOTE1(n__cons(X, Z)) → ACTIVATE(X)
ACTIVATE(n__first(X1, X2)) → FIRST(X1, X2)
UNQUOTE(01) → 01
SEL(s(X), cons(Y, Z)) → ACTIVATE(Z)
UNQUOTE1(cons1(X, Z)) → UNQUOTE(X)
FIRST(0, Z) → NIL
FIRST1(s(X), cons(Y, Z)) → FIRST1(X, activate(Z))
QUOTE1(n__first(X, Z)) → FIRST1(activate(X), activate(Z))
FROM(X) → S(X)
QUOTE1(n__cons(X, Z)) → QUOTE(activate(X))
QUOTE(n__sel(X, Z)) → ACTIVATE(X)
UNQUOTE(s1(X)) → UNQUOTE(X)
SEL1(s(X), cons(Y, Z)) → ACTIVATE(Z)
ACTIVATE(n__0) → 01
FIRST(s(X), cons(Y, Z)) → CONS(Y, n__first(X, activate(Z)))
QUOTE(n__sel(X, Z)) → SEL1(activate(X), activate(Z))
ACTIVATE(n__cons(X1, X2)) → CONS(X1, X2)
ACTIVATE(n__from(X)) → FROM(X)
UNQUOTE1(cons1(X, Z)) → UNQUOTE1(Z)
SEL1(s(X), cons(Y, Z)) → SEL1(X, activate(Z))
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE1(n__first(X, Z)) → ACTIVATE(X)
QUOTE1(n__cons(X, Z)) → QUOTE1(activate(Z))
QUOTE(n__s(X)) → QUOTE(activate(X))
FROM(X) → CONS(X, n__from(s(X)))
ACTIVATE(n__nil) → NIL
ACTIVATE(n__s(X)) → S(X)
QUOTE1(n__cons(X, Z)) → ACTIVATE(Z)
UNQUOTE(s1(X)) → S(unquote(X))
FIRST1(s(X), cons(Y, Z)) → ACTIVATE(Z)
QUOTE(n__s(X)) → ACTIVATE(X)
FIRST1(s(X), cons(Y, Z)) → QUOTE(Y)
UNQUOTE1(nil1) → NIL
QUOTE(n__sel(X, Z)) → ACTIVATE(Z)
FIRST(s(X), cons(Y, Z)) → ACTIVATE(Z)
SEL(s(X), cons(Y, Z)) → SEL(X, activate(Z))
QUOTE1(n__first(X, Z)) → ACTIVATE(Z)
FCONS(X, Z) → CONS(X, Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS
  ↳ DependencyPairsProof
QDP
      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

ACTIVATE(n__sel(X1, X2)) → SEL(X1, X2)
UNQUOTE1(cons1(X, Z)) → FCONS(unquote(X), unquote1(Z))
QUOTE1(n__cons(X, Z)) → ACTIVATE(X)
ACTIVATE(n__first(X1, X2)) → FIRST(X1, X2)
UNQUOTE(01) → 01
SEL(s(X), cons(Y, Z)) → ACTIVATE(Z)
UNQUOTE1(cons1(X, Z)) → UNQUOTE(X)
FIRST(0, Z) → NIL
FIRST1(s(X), cons(Y, Z)) → FIRST1(X, activate(Z))
QUOTE1(n__first(X, Z)) → FIRST1(activate(X), activate(Z))
FROM(X) → S(X)
QUOTE1(n__cons(X, Z)) → QUOTE(activate(X))
QUOTE(n__sel(X, Z)) → ACTIVATE(X)
UNQUOTE(s1(X)) → UNQUOTE(X)
SEL1(s(X), cons(Y, Z)) → ACTIVATE(Z)
ACTIVATE(n__0) → 01
FIRST(s(X), cons(Y, Z)) → CONS(Y, n__first(X, activate(Z)))
QUOTE(n__sel(X, Z)) → SEL1(activate(X), activate(Z))
ACTIVATE(n__cons(X1, X2)) → CONS(X1, X2)
ACTIVATE(n__from(X)) → FROM(X)
UNQUOTE1(cons1(X, Z)) → UNQUOTE1(Z)
SEL1(s(X), cons(Y, Z)) → SEL1(X, activate(Z))
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE1(n__first(X, Z)) → ACTIVATE(X)
QUOTE1(n__cons(X, Z)) → QUOTE1(activate(Z))
QUOTE(n__s(X)) → QUOTE(activate(X))
FROM(X) → CONS(X, n__from(s(X)))
ACTIVATE(n__nil) → NIL
ACTIVATE(n__s(X)) → S(X)
QUOTE1(n__cons(X, Z)) → ACTIVATE(Z)
UNQUOTE(s1(X)) → S(unquote(X))
FIRST1(s(X), cons(Y, Z)) → ACTIVATE(Z)
QUOTE(n__s(X)) → ACTIVATE(X)
FIRST1(s(X), cons(Y, Z)) → QUOTE(Y)
UNQUOTE1(nil1) → NIL
QUOTE(n__sel(X, Z)) → ACTIVATE(Z)
FIRST(s(X), cons(Y, Z)) → ACTIVATE(Z)
SEL(s(X), cons(Y, Z)) → SEL(X, activate(Z))
QUOTE1(n__first(X, Z)) → ACTIVATE(Z)
FCONS(X, Z) → CONS(X, Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 6 SCCs with 27 less nodes.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
QDP
            ↳ UsableRulesProof
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

UNQUOTE(s1(X)) → UNQUOTE(X)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We can use the usable rules and reduction pair processor [15] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its argument. Then, we can delete all non-usable rules [17] from R.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
            ↳ UsableRulesProof
QDP
                ↳ QDPSizeChangeProof
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

UNQUOTE(s1(X)) → UNQUOTE(X)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
QDP
            ↳ UsableRulesProof
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

UNQUOTE1(cons1(X, Z)) → UNQUOTE1(Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We can use the usable rules and reduction pair processor [15] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its argument. Then, we can delete all non-usable rules [17] from R.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
            ↳ UsableRulesProof
QDP
                ↳ QDPSizeChangeProof
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

UNQUOTE1(cons1(X, Z)) → UNQUOTE1(Z)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
QDP
            ↳ QDPOrderProof
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVATE(n__sel(X1, X2)) → SEL(X1, X2)
ACTIVATE(n__first(X1, X2)) → FIRST(X1, X2)
SEL(s(X), cons(Y, Z)) → ACTIVATE(Z)
SEL(s(X), cons(Y, Z)) → SEL(X, activate(Z))
FIRST(s(X), cons(Y, Z)) → ACTIVATE(Z)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


ACTIVATE(n__sel(X1, X2)) → SEL(X1, X2)
FIRST(s(X), cons(Y, Z)) → ACTIVATE(Z)
The remaining pairs can at least be oriented weakly.

ACTIVATE(n__first(X1, X2)) → FIRST(X1, X2)
SEL(s(X), cons(Y, Z)) → ACTIVATE(Z)
SEL(s(X), cons(Y, Z)) → SEL(X, activate(Z))
Used ordering: Polynomial interpretation [25]:

POL(0) = 0   
POL(ACTIVATE(x1)) = x1   
POL(FIRST(x1, x2)) = 1 + x2   
POL(SEL(x1, x2)) = x2   
POL(activate(x1)) = x1   
POL(cons(x1, x2)) = x1 + x2   
POL(first(x1, x2)) = 1 + x2   
POL(from(x1)) = x1   
POL(n__0) = 0   
POL(n__cons(x1, x2)) = x1 + x2   
POL(n__first(x1, x2)) = 1 + x2   
POL(n__from(x1)) = x1   
POL(n__nil) = 1   
POL(n__s(x1)) = 0   
POL(n__sel(x1, x2)) = 1 + x2   
POL(nil) = 1   
POL(s(x1)) = 0   
POL(sel(x1, x2)) = 1 + x2   

The following usable rules [17] were oriented:

from(X) → n__from(X)
0n__0
first(X1, X2) → n__first(X1, X2)
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__0) → 0
activate(n__from(X)) → from(X)
activate(n__first(X1, X2)) → first(X1, X2)
sel(X1, X2) → n__sel(X1, X2)
s(X) → n__s(X)
niln__nil
cons(X1, X2) → n__cons(X1, X2)
from(X) → cons(X, n__from(s(X)))
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
activate(X) → X
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(n__s(X)) → s(X)
first(0, Z) → nil
activate(n__nil) → nil
sel(0, cons(X, Z)) → X



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
QDP
                ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SEL(s(X), cons(Y, Z)) → ACTIVATE(Z)
ACTIVATE(n__first(X1, X2)) → FIRST(X1, X2)
SEL(s(X), cons(Y, Z)) → SEL(X, activate(Z))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 2 less nodes.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ DependencyGraphProof
QDP
                    ↳ QDPSizeChangeProof
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SEL(s(X), cons(Y, Z)) → SEL(X, activate(Z))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
QDP
            ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__s(X)) → QUOTE(activate(X))
QUOTE(n__sel(X, Z)) → SEL1(activate(X), activate(Z))
SEL1(s(X), cons(Y, Z)) → SEL1(X, activate(Z))
SEL1(0, cons(X, Z)) → QUOTE(X)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__s(X)) → QUOTE(activate(X)) at position [0] we obtained the following new rules:

QUOTE(n__s(n__nil)) → QUOTE(nil)
QUOTE(n__s(n__cons(x0, x1))) → QUOTE(cons(x0, x1))
QUOTE(n__s(n__0)) → QUOTE(0)
QUOTE(n__s(n__s(x0))) → QUOTE(s(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__s(n__from(x0))) → QUOTE(from(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
QDP
                ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(X, Z)) → SEL1(activate(X), activate(Z))
QUOTE(n__s(n__nil)) → QUOTE(nil)
QUOTE(n__s(n__cons(x0, x1))) → QUOTE(cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(s(x0))
QUOTE(n__s(n__0)) → QUOTE(0)
QUOTE(n__s(n__from(x0))) → QUOTE(from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
SEL1(s(X), cons(Y, Z)) → SEL1(X, activate(Z))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(X, Z)) → SEL1(activate(X), activate(Z)) at position [0] we obtained the following new rules:

QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
QDP
                    ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
QUOTE(n__s(n__nil)) → QUOTE(nil)
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__s(n__s(x0))) → QUOTE(s(x0))
QUOTE(n__s(n__0)) → QUOTE(0)
QUOTE(n__s(n__from(x0))) → QUOTE(from(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
QUOTE(n__s(n__cons(x0, x1))) → QUOTE(cons(x0, x1))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
SEL1(s(X), cons(Y, Z)) → SEL1(X, activate(Z))
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
SEL1(0, cons(X, Z)) → QUOTE(X)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule SEL1(s(X), cons(Y, Z)) → SEL1(X, activate(Z)) at position [1] we obtained the following new rules:

SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
QDP
                        ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__nil)) → QUOTE(nil)
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(from(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__s(n__cons(x0, x1))) → QUOTE(cons(x0, x1))
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__s(n__s(x0))) → QUOTE(s(x0))
QUOTE(n__s(n__0)) → QUOTE(0)
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__s(n__nil)) → QUOTE(nil) at position [0] we obtained the following new rules:

QUOTE(n__s(n__nil)) → QUOTE(n__nil)



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
QDP
                            ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(from(x0))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__cons(x0, x1))) → QUOTE(cons(x0, x1))
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__s(n__0)) → QUOTE(0)
QUOTE(n__s(n__s(x0))) → QUOTE(s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__s(n__nil)) → QUOTE(n__nil)
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
QDP
                                ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__s(n__0)) → QUOTE(0)
QUOTE(n__s(n__s(x0))) → QUOTE(s(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(from(x0))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__cons(x0, x1))) → QUOTE(cons(x0, x1))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__s(n__cons(x0, x1))) → QUOTE(cons(x0, x1)) at position [0] we obtained the following new rules:

QUOTE(n__s(n__cons(x0, x1))) → QUOTE(n__cons(x0, x1))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
QDP
                                    ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(from(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__cons(x0, x1))) → QUOTE(n__cons(x0, x1))
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__s(n__s(x0))) → QUOTE(s(x0))
QUOTE(n__s(n__0)) → QUOTE(0)
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
QDP
                                        ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__s(n__0)) → QUOTE(0)
QUOTE(n__s(n__s(x0))) → QUOTE(s(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(from(x0))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__s(n__0)) → QUOTE(0) at position [0] we obtained the following new rules:

QUOTE(n__s(n__0)) → QUOTE(n__0)



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
QDP
                                            ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__s(n__s(x0))) → QUOTE(s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__s(n__0)) → QUOTE(n__0)
QUOTE(n__s(n__from(x0))) → QUOTE(from(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
QDP
                                                ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__s(n__s(x0))) → QUOTE(s(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(from(x0))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__s(n__s(x0))) → QUOTE(s(x0)) at position [0] we obtained the following new rules:

QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
QDP
                                                    ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(from(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__s(n__from(x0))) → QUOTE(from(x0)) at position [0] we obtained the following new rules:

QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__s(n__from(x0))) → QUOTE(n__from(x0))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
QDP
                                                        ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__s(n__from(x0))) → QUOTE(n__from(x0))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
QDP
                                                            ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__first(x0, x1), y1)) → SEL1(first(x0, x1), activate(y1)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
QDP
                                                                ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__s(x0), y1)) → SEL1(s(x0), activate(y1)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
QDP
                                                                    ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, from(x0)) at position [1] we obtained the following new rules:

SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, n__from(x0))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
QDP
                                                                        ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, n__from(x0))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
QDP
                                                                            ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__0, y1)) → SEL1(0, activate(y1)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
QDP
                                                                                ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__from(x0), y1)) → SEL1(from(x0), activate(y1)) at position [0] we obtained the following new rules:

QUOTE(n__sel(n__from(x0), y1)) → SEL1(n__from(x0), activate(y1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
QDP
                                                                                    ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__from(x0), y1)) → SEL1(n__from(x0), activate(y1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
QDP
                                                                                        ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__cons(x0, x1), y1)) → SEL1(cons(x0, x1), activate(y1)) at position [0] we obtained the following new rules:

QUOTE(n__sel(n__cons(x0, x1), y2)) → SEL1(n__cons(x0, x1), activate(y2))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
QDP
                                                                                            ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__cons(x0, x1), y2)) → SEL1(n__cons(x0, x1), activate(y2))
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
QDP
                                                                                                ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__sel(x0, x1), y1)) → SEL1(sel(x0, x1), activate(y1)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
QDP
                                                                                                    ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__nil, y1)) → SEL1(nil, activate(y1)) at position [0] we obtained the following new rules:

QUOTE(n__sel(n__nil, y0)) → SEL1(n__nil, activate(y0))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
QDP
                                                                                                        ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(n__nil, y0)) → SEL1(n__nil, activate(y0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
QDP
                                                                                                            ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(x0, y1)) → SEL1(x0, activate(y1)) at position [1] we obtained the following new rules:

QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
QDP
                                                                                                                ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, s(x0)) at position [1] we obtained the following new rules:

SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, n__s(x0))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
QDP
                                                                                                                    ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
SEL1(s(y0), cons(y1, n__s(x0))) → SEL1(y0, n__s(x0))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
QDP
                                                                                                                        ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, 0) at position [1] we obtained the following new rules:

SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, n__0)



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
QDP
                                                                                                                            ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
SEL1(s(y0), cons(y1, n__0)) → SEL1(y0, n__0)
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
QDP
                                                                                                                                ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, nil) at position [1] we obtained the following new rules:

SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, n__nil)



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
QDP
                                                                                                                                    ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
SEL1(s(y0), cons(y1, n__nil)) → SEL1(y0, n__nil)
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
QDP
                                                                                                                                        ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), s(x0)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), n__s(x0))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
QDP
                                                                                                                                            ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__s(x0))) → SEL1(first(y0, y1), n__s(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
QDP
                                                                                                                                                ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), nil) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), n__nil)



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
QDP
                                                                                                                                                    ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__nil)) → SEL1(first(y0, y1), n__nil)
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
QDP
                                                                                                                                                        ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), from(x0)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), n__from(x0))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
QDP
                                                                                                                                                            ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), n__from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
QDP
                                                                                                                                                                ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), 0) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), n__0)



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
QDP
                                                                                                                                                                    ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__0)) → SEL1(first(y0, y1), n__0)
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
QDP
                                                                                                                                                                        ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), from(x0)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), n__from(x0))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
QDP
                                                                                                                                                                            ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), n__from(x0))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
QDP
                                                                                                                                                                                ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil)
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), nil) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), n__nil)



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__nil)) → SEL1(s(y0), n__nil)
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
QDP
                                                                                                                                                                                        ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0)
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), 0) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), n__0)



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__0)) → SEL1(s(y0), n__0)
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
QDP
                                                                                                                                                                                                ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), s(x0)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), n__s(x0))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__s(y0), n__s(x0))) → SEL1(s(y0), n__s(x0))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
QDP
                                                                                                                                                                                                        ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, s(x0)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, n__s(x0))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__s(x0))) → SEL1(0, n__s(x0))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
QDP
                                                                                                                                                                                                                ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__0, n__nil)) → SEL1(0, nil) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__0, n__nil)) → SEL1(0, n__nil)



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__nil)) → SEL1(0, n__nil)
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
QDP
                                                                                                                                                                                                                        ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, from(x0)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, n__from(x0))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Narrowing
QDP
                                                                                                                                                                                                                            ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, n__from(x0))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ DependencyGraphProof
QDP
                                                                                                                                                                                                                                ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0)
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__0, n__0)) → SEL1(0, 0) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__0, n__0)) → SEL1(0, n__0)



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Narrowing
QDP
                                                                                                                                                                                                                                    ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__0, n__0)) → SEL1(0, n__0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ DependencyGraphProof
QDP
                                                                                                                                                                                                                                        ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), s(x0)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), n__s(x0))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Narrowing
QDP
                                                                                                                                                                                                                                            ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__s(x0))) → SEL1(sel(y0, y1), n__s(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ DependencyGraphProof
QDP
                                                                                                                                                                                                                                                ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), nil) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), n__nil)



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Narrowing
QDP
                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__nil)) → SEL1(sel(y0, y1), n__nil)
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
QDP
                                                                                                                                                                                                                                                        ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), from(x0)) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), n__from(x0))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Narrowing
QDP
                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), n__from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
QDP
                                                                                                                                                                                                                                                                ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), 0) at position [1] we obtained the following new rules:

QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), n__0)



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ Narrowing
QDP
                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__0)) → SEL1(sel(y0, y1), n__0)
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
QDP
                                                                                                                                                                                                                                                                        ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, from(x0)) at position [1] we obtained the following new rules:

QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, n__from(x0))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                                        ↳ Narrowing
QDP
                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, n__from(x0))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
QDP
                                                                                                                                                                                                                                                                                ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0)
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(y0, n__0)) → SEL1(y0, 0) at position [1] we obtained the following new rules:

QUOTE(n__sel(y0, n__0)) → SEL1(y0, n__0)



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                                ↳ Narrowing
QDP
                                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, n__0)) → SEL1(y0, n__0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
QDP
                                                                                                                                                                                                                                                                                        ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, s(x0)) at position [1] we obtained the following new rules:

QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, n__s(x0))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                                                        ↳ Narrowing
QDP
                                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(y0, n__s(x0))) → SEL1(y0, n__s(x0))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
QDP
                                                                                                                                                                                                                                                                                                ↳ Narrowing
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE(n__sel(y0, n__nil)) → SEL1(y0, nil) at position [1] we obtained the following new rules:

QUOTE(n__sel(y0, n__nil)) → SEL1(y0, n__nil)



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                                                ↳ Narrowing
QDP
                                                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(y0, n__nil)) → SEL1(y0, n__nil)
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
QDP
                                                                                                                                                                                                                                                                                                        ↳ QDPOrderProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


QUOTE(n__sel(n__sel(y0, y1), n__from(x0))) → SEL1(sel(y0, y1), cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__0, n__cons(x0, x1))) → SEL1(0, cons(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__cons(x0, x1))) → SEL1(first(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__sel(x0, x1))) → SEL1(sel(y0, y1), sel(x0, x1))
QUOTE(n__sel(n__s(y0), n__sel(x0, x1))) → SEL1(s(y0), sel(x0, x1))
QUOTE(n__sel(y0, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__s(n__sel(x0, x1))) → QUOTE(sel(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), x0)) → SEL1(sel(y0, y1), x0)
QUOTE(n__s(n__first(x0, x1))) → QUOTE(first(x0, x1))
QUOTE(n__sel(y0, n__sel(x0, x1))) → SEL1(y0, sel(x0, x1))
QUOTE(n__sel(n__first(y0, y1), x0)) → SEL1(first(y0, y1), x0)
QUOTE(n__sel(n__s(y0), n__cons(x0, x1))) → SEL1(s(y0), cons(x0, x1))
QUOTE(n__sel(n__s(y0), n__first(x0, x1))) → SEL1(s(y0), first(x0, x1))
QUOTE(n__sel(y0, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__sel(n__s(y0), x0)) → SEL1(s(y0), x0)
QUOTE(n__sel(n__0, n__first(x0, x1))) → SEL1(0, first(x0, x1))
SEL1(s(y0), cons(y1, x0)) → SEL1(y0, x0)
SEL1(0, cons(X, Z)) → QUOTE(X)
SEL1(s(y0), cons(y1, n__from(x0))) → SEL1(y0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__first(y0, y1), n__from(x0))) → SEL1(first(y0, y1), cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__0, x0)) → SEL1(0, x0)
QUOTE(n__sel(n__sel(y0, y1), n__cons(x0, x1))) → SEL1(sel(y0, y1), cons(x0, x1))
QUOTE(n__sel(n__sel(y0, y1), n__first(x0, x1))) → SEL1(sel(y0, y1), first(x0, x1))
QUOTE(n__sel(n__first(y0, y1), n__sel(x0, x1))) → SEL1(first(y0, y1), sel(x0, x1))
QUOTE(n__sel(y0, x0)) → SEL1(y0, x0)
QUOTE(n__sel(n__0, n__sel(x0, x1))) → SEL1(0, sel(x0, x1))
QUOTE(n__s(n__from(x0))) → QUOTE(cons(x0, n__from(s(x0))))
SEL1(s(y0), cons(y1, n__cons(x0, x1))) → SEL1(y0, cons(x0, x1))
QUOTE(n__s(n__s(x0))) → QUOTE(n__s(x0))
QUOTE(n__s(x0)) → QUOTE(x0)
QUOTE(n__sel(n__first(y0, y1), n__first(x0, x1))) → SEL1(first(y0, y1), first(x0, x1))
QUOTE(n__sel(n__0, n__from(x0))) → SEL1(0, cons(x0, n__from(s(x0))))
QUOTE(n__sel(n__s(y0), n__from(x0))) → SEL1(s(y0), cons(x0, n__from(s(x0))))
QUOTE(n__sel(y0, n__first(x0, x1))) → SEL1(y0, first(x0, x1))
QUOTE(n__sel(n__from(x0), y1)) → SEL1(cons(x0, n__from(s(x0))), activate(y1))
The remaining pairs can at least be oriented weakly.
none
Used ordering: Combined order from the following AFS and order.
QUOTE(x1)  =  QUOTE(x1)
n__sel(x1, x2)  =  n__sel(x1, x2)
n__from(x1)  =  n__from(x1)
SEL1(x1, x2)  =  SEL1(x1, x2)
sel(x1, x2)  =  sel(x1, x2)
cons(x1, x2)  =  cons(x1, x2)
s(x1)  =  s(x1)
n__0  =  n__0
n__cons(x1, x2)  =  n__cons(x1, x2)
0  =  0
n__first(x1, x2)  =  n__first(x1, x2)
first(x1, x2)  =  first(x1, x2)
n__s(x1)  =  n__s(x1)
activate(x1)  =  activate(x1)
from(x1)  =  from(x1)
nil  =  nil
n__nil  =  n__nil

Recursive path order with status [2].
Quasi-Precedence:
[nsel2, sel2, nfirst2, first2] > [activate1, from1] > [SEL12, n0, 0] > QUOTE1 > [s1, ns1] > [nfrom1, cons2, ncons2]
[nsel2, sel2, nfirst2, first2] > [nil, nnil]

Status:
sel2: [1,2]
nfirst2: [1,2]
SEL12: [1,2]
from1: [1]
nsel2: [1,2]
ncons2: multiset
activate1: [1]
ns1: multiset
nnil: multiset
0: multiset
first2: [1,2]
cons2: multiset
nfrom1: multiset
n0: multiset
s1: multiset
nil: multiset
QUOTE1: [1]


The following usable rules [17] were oriented:

from(X) → cons(X, n__from(s(X)))
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
first(0, Z) → nil
sel(0, cons(X, Z)) → X
from(X) → n__from(X)
0n__0
first(X1, X2) → n__first(X1, X2)
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__0) → 0
activate(n__from(X)) → from(X)
activate(n__first(X1, X2)) → first(X1, X2)
sel(X1, X2) → n__sel(X1, X2)
s(X) → n__s(X)
niln__nil
cons(X1, X2) → n__cons(X1, X2)
activate(X) → X
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(n__s(X)) → s(X)
activate(n__nil) → nil



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ Narrowing
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ DependencyGraphProof
                                                          ↳ QDP
                                                            ↳ Narrowing
                                                              ↳ QDP
                                                                ↳ Narrowing
                                                                  ↳ QDP
                                                                    ↳ Narrowing
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Narrowing
                                                                              ↳ QDP
                                                                                ↳ Narrowing
                                                                                  ↳ QDP
                                                                                    ↳ DependencyGraphProof
                                                                                      ↳ QDP
                                                                                        ↳ Narrowing
                                                                                          ↳ QDP
                                                                                            ↳ DependencyGraphProof
                                                                                              ↳ QDP
                                                                                                ↳ Narrowing
                                                                                                  ↳ QDP
                                                                                                    ↳ Narrowing
                                                                                                      ↳ QDP
                                                                                                        ↳ DependencyGraphProof
                                                                                                          ↳ QDP
                                                                                                            ↳ Narrowing
                                                                                                              ↳ QDP
                                                                                                                ↳ Narrowing
                                                                                                                  ↳ QDP
                                                                                                                    ↳ DependencyGraphProof
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Narrowing
                                                                                                                          ↳ QDP
                                                                                                                            ↳ DependencyGraphProof
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Narrowing
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Narrowing
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Narrowing
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Narrowing
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ QDP
                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                  ↳ QDP
                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                      ↳ QDP
                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                          ↳ QDP
                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                                                        ↳ Narrowing
                                                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                                                ↳ Narrowing
                                                                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                                                                        ↳ QDPOrderProof
QDP
                                                                                                                                                                                                                                                                                                            ↳ PisEmptyProof
          ↳ QDP
          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
QDP
            ↳ QDPSizeChangeProof
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FIRST1(s(X), cons(Y, Z)) → FIRST1(X, activate(Z))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
QDP
            ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(X, Z)) → QUOTE1(activate(Z))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE1(n__cons(X, Z)) → QUOTE1(activate(Z)) at position [0] we obtained the following new rules:

QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__0)) → QUOTE1(0)
QUOTE1(n__cons(y0, n__nil)) → QUOTE1(nil)
QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))
QUOTE1(n__cons(y0, n__s(x0))) → QUOTE1(s(x0))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(from(x0))
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(cons(x0, x1))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
QDP
                ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__nil)) → QUOTE1(nil)
QUOTE1(n__cons(y0, n__0)) → QUOTE1(0)
QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))
QUOTE1(n__cons(y0, n__s(x0))) → QUOTE1(s(x0))
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(cons(x0, x1))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(from(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE1(n__cons(y0, n__0)) → QUOTE1(0) at position [0] we obtained the following new rules:

QUOTE1(n__cons(y0, n__0)) → QUOTE1(n__0)



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
QDP
                    ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__nil)) → QUOTE1(nil)
QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__0)) → QUOTE1(n__0)
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))
QUOTE1(n__cons(y0, n__s(x0))) → QUOTE1(s(x0))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(from(x0))
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(cons(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ DependencyGraphProof
QDP
                        ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__nil)) → QUOTE1(nil)
QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))
QUOTE1(n__cons(y0, n__s(x0))) → QUOTE1(s(x0))
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(cons(x0, x1))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(from(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE1(n__cons(y0, n__nil)) → QUOTE1(nil) at position [0] we obtained the following new rules:

QUOTE1(n__cons(y0, n__nil)) → QUOTE1(n__nil)



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ DependencyGraphProof
                      ↳ QDP
                        ↳ Narrowing
QDP
                            ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__nil)) → QUOTE1(n__nil)
QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))
QUOTE1(n__cons(y0, n__s(x0))) → QUOTE1(s(x0))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(from(x0))
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(cons(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ DependencyGraphProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
QDP
                                ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))
QUOTE1(n__cons(y0, n__s(x0))) → QUOTE1(s(x0))
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(cons(x0, x1))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(from(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE1(n__cons(y0, n__s(x0))) → QUOTE1(s(x0)) at position [0] we obtained the following new rules:

QUOTE1(n__cons(y0, n__s(x0))) → QUOTE1(n__s(x0))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ DependencyGraphProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
QDP
                                    ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(y0, n__s(x0))) → QUOTE1(n__s(x0))
QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(from(x0))
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(cons(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ DependencyGraphProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
QDP
                                        ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(cons(x0, x1))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(from(x0))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(from(x0)) at position [0] we obtained the following new rules:

QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(cons(x0, n__from(s(x0))))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(n__from(x0))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ DependencyGraphProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
QDP
                                            ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(n__from(x0))
QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(cons(x0, n__from(s(x0))))
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(cons(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ DependencyGraphProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
QDP
                                                ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(cons(x0, n__from(s(x0))))
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(cons(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(cons(x0, x1)) at position [0] we obtained the following new rules:

QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(n__cons(x0, x1))



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ DependencyGraphProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
QDP
                                                    ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(n__cons(x0, x1))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(cons(x0, n__from(s(x0))))
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


QUOTE1(n__cons(y0, x0)) → QUOTE1(x0)
QUOTE1(n__cons(y0, n__cons(x0, x1))) → QUOTE1(n__cons(x0, x1))
QUOTE1(n__cons(y0, n__sel(x0, x1))) → QUOTE1(sel(x0, x1))
The remaining pairs can at least be oriented weakly.

QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(cons(x0, n__from(s(x0))))
Used ordering: Polynomial interpretation [25]:

POL(0) = 1   
POL(QUOTE1(x1)) = x1   
POL(activate(x1)) = 1 + x1   
POL(cons(x1, x2)) = 1 + x1 + x2   
POL(first(x1, x2)) = 1 + x2   
POL(from(x1)) = 1 + x1   
POL(n__0) = 0   
POL(n__cons(x1, x2)) = 1 + x1 + x2   
POL(n__first(x1, x2)) = x2   
POL(n__from(x1)) = x1   
POL(n__nil) = 0   
POL(n__s(x1)) = 0   
POL(n__sel(x1, x2)) = 1 + x2   
POL(nil) = 1   
POL(s(x1)) = 0   
POL(sel(x1, x2)) = 1 + x2   

The following usable rules [17] were oriented:

from(X) → n__from(X)
0n__0
first(X1, X2) → n__first(X1, X2)
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__0) → 0
activate(n__from(X)) → from(X)
activate(n__first(X1, X2)) → first(X1, X2)
sel(X1, X2) → n__sel(X1, X2)
s(X) → n__s(X)
niln__nil
cons(X1, X2) → n__cons(X1, X2)
from(X) → cons(X, n__from(s(X)))
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
activate(X) → X
sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(n__s(X)) → s(X)
first(0, Z) → nil
sel(0, cons(X, Z)) → X
activate(n__nil) → nil



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ Narrowing
              ↳ QDP
                ↳ Narrowing
                  ↳ QDP
                    ↳ DependencyGraphProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ DependencyGraphProof
                                      ↳ QDP
                                        ↳ Narrowing
                                          ↳ QDP
                                            ↳ DependencyGraphProof
                                              ↳ QDP
                                                ↳ Narrowing
                                                  ↳ QDP
                                                    ↳ QDPOrderProof
QDP
                                                        ↳ NonTerminationProof

Q DP problem:
The TRS P consists of the following rules:

QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(cons(x0, n__from(s(x0))))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We used the non-termination processor [17] to show that the DP problem is infinite.
Found a loop by narrowing to the left:

The TRS P consists of the following rules:

QUOTE1(n__cons(y0, n__first(x0, x1))) → QUOTE1(first(x0, x1))
QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(cons(x0, n__from(s(x0))))

The TRS R consists of the following rules:

sel(s(X), cons(Y, Z)) → sel(X, activate(Z))
sel(0, cons(X, Z)) → X
first(0, Z) → nil
first(s(X), cons(Y, Z)) → cons(Y, n__first(X, activate(Z)))
from(X) → cons(X, n__from(s(X)))
sel1(s(X), cons(Y, Z)) → sel1(X, activate(Z))
sel1(0, cons(X, Z)) → quote(X)
first1(0, Z) → nil1
first1(s(X), cons(Y, Z)) → cons1(quote(Y), first1(X, activate(Z)))
quote(n__0) → 01
quote1(n__cons(X, Z)) → cons1(quote(activate(X)), quote1(activate(Z)))
quote1(n__nil) → nil1
quote(n__s(X)) → s1(quote(activate(X)))
quote(n__sel(X, Z)) → sel1(activate(X), activate(Z))
quote1(n__first(X, Z)) → first1(activate(X), activate(Z))
unquote(01) → 0
unquote(s1(X)) → s(unquote(X))
unquote1(nil1) → nil
unquote1(cons1(X, Z)) → fcons(unquote(X), unquote1(Z))
fcons(X, Z) → cons(X, Z)
first(X1, X2) → n__first(X1, X2)
from(X) → n__from(X)
0n__0
cons(X1, X2) → n__cons(X1, X2)
niln__nil
s(X) → n__s(X)
sel(X1, X2) → n__sel(X1, X2)
activate(n__first(X1, X2)) → first(X1, X2)
activate(n__from(X)) → from(X)
activate(n__0) → 0
activate(n__cons(X1, X2)) → cons(X1, X2)
activate(n__nil) → nil
activate(n__s(X)) → s(X)
activate(n__sel(X1, X2)) → sel(X1, X2)
activate(X) → X


s = QUOTE1(cons(X1, n__from(x0))) evaluates to t =QUOTE1(cons(x0, n__from(s(x0))))

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:




Rewriting sequence

QUOTE1(cons(X1, n__from(x0)))QUOTE1(n__cons(X1, n__from(x0)))
with rule cons(X1', X2) → n__cons(X1', X2) at position [0] and matcher [X2 / n__from(x0), X1' / X1]

QUOTE1(n__cons(X1, n__from(x0)))QUOTE1(cons(x0, n__from(s(x0))))
with rule QUOTE1(n__cons(y0, n__from(x0))) → QUOTE1(cons(x0, n__from(s(x0))))

Now applying the matcher to the start term leads to a term which is equal to the last term in the rewriting sequence


All these steps are and every following step will be a correct step w.r.t to Q.